package main

import (
	"context"
	"fmt"
	"runtime"
	"time"
)

//
//func main() {
//	//conn := sqlx.NewMysql("gozero:gozero123@tcp(192.168.10.60:3306)/zerotest?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghai")
//	// 事务测试
//	//insertstr1 := "INSERT INTO user (username,mobile) VALUES ('lcj','13988886666');"
//	////insertstr2 := "INSERT INTO ***;"
//	//insertstr2err := "INSERT INTO user (username,mobile) VALUES ('lcj2','13988886667');"
//
//	//err := conn.Transact(func(session sqlx.Session) error {
//	//
//	//	res, err := session.Exec(insertstr1)
//	//	if err != nil {
//	//		return err
//	//	}
//	//	lastID, _ := res.LastInsertId()
//	//	fmt.Printf("res 1: %d", lastID)
//	//
//	//	// 此处操作如果没有报错，则，1，2，二处操作数据库都插入数据成功。
//	//	// 此处操作如果报错，则，1，2 二处操作数据库都不会插入数据。1 插入后回滚了。
//	//	//res2, err := session.Exec(insertstr2)
//	//	res2, err := session.Exec(insertstr2err) // 出错的 SQL
//	//	if err != nil {
//	//		return err
//	//	}
//	//	lastID2, _ := res2.LastInsertId()
//	//	fmt.Printf("res 2: %d", lastID2)
//	//
//	//	return nil
//	//})
//	//if err != nil {
//	//	fmt.Printf("Transact fail:%v", err)
//	//}
//	//var resp User
//	//t1 := time.Now()
//	//query := "select * from user where id=?"
//	//err := conn.QueryRowCtx(context.Background(), &resp, query, 1)
//	//t2 := time.Now()
//	//fmt.Println("time:", t2.Sub(t1))
//	//if err != nil {
//	//	panic(err)
//	//}
//	//fmt.Println(resp)
//	a := new(int)
//	fmt.Printf("%#v", a)
//	fmt.Printf("%#v", *a)
//	type Student struct {
//		name string
//		age  int
//	}
//	var s *Student
//	s = new(Student) //分配空间
//	s.name = "zhangsan"
//	fmt.Println(s)
//}

// func foo([]interface{}) { /* do something */ }

//type Node struct {
//	key   int
//	value string
//	left  *Node
//	right *Node
//}
//
//type BinarySearchTree struct {
//	root *Node
//	lock sync.RWMutex
//}
//
//func (bst *BinarySearchTree) Insert(key int, value string) {
//	bst.lock.Lock()
//	defer bst.lock.Unlock()
//	node := &Node{key, value, nil, nil}
//	if bst.root == nil {
//		bst.root = node
//
//	} else {
//		insertNode(node, bst.root)
//	}
//}
//
//func insertNode(node *Node, treeNode *Node) {
//	//fmt.Println(treeNode.left, treeNode.right)
//	if node.key < treeNode.key {
//		if treeNode.left == nil {
//			treeNode.left = node
//			return
//
//		} else {
//			insertNode(node, treeNode.left)
//		}
//	} else {
//		if treeNode.right == nil {
//			treeNode.right = node
//			return
//		} else {
//			insertNode(node, treeNode.right)
//		}
//	}
//
//}
//func (bst *BinarySearchTree) InOrderTraverse() {
//	bst.lock.Lock()
//	defer bst.lock.Unlock()
//	inOrderTraverse(bst.root)
//}
//func (bst *BinarySearchTree) PreOrderTraverse() {
//	bst.lock.Lock()
//	defer bst.lock.Unlock()
//	preOrderTraverse(bst.root)
//}
//func (bst *BinarySearchTree) PostOrderTraverse() {
//	bst.lock.Lock()
//	defer bst.lock.Unlock()
//	postOrderTraverse(bst.root)
//}
//
//func (bst *BinarySearchTree) Search(key int) bool {
//	bst.lock.Lock()
//	defer bst.lock.Unlock()
//
//	ok := search2(bst.root, key)
//	return ok
//
//}
//func (bst *BinarySearchTree) Min() (*Node, error) {
//	bst.lock.Lock()
//	defer bst.lock.Unlock()
//	if bst.root == nil {
//		return nil, errors.New("没有节点")
//	}
//	n := bst.root
//	for {
//
//		if n.left == nil {
//			return n, nil
//		}
//		n = n.left
//
//	}
//}
//
//// 给出一个node查找他的下级最小的node
//func minNode(node *Node) *Node {
//	var lock sync.RWMutex
//	lock.Lock()
//	defer lock.Unlock()
//	for {
//		if node.left == nil {
//			return node
//		}
//		node = node.left
//	}
//}
//func (bst *BinarySearchTree) Delete(key int) error {
//	bst.lock.Lock()
//	defer bst.lock.Unlock()
//
//	remove(bst.root, key)
//	return nil
//}
//func remove(node *Node, key int) *Node {
//	if node == nil {
//		return nil
//	}
//	if key < node.key {
//		node.left = remove(node.left, key)
//		return node
//	}
//	if key > node.key {
//		node.right = remove(node.right, key)
//		return node
//	}
//	// key == node.key
//	if node.left == nil && node.right == nil {
//		node = nil
//		return nil
//	}
//	if node.left == nil {
//		node = node.right
//		return node
//	}
//	if node.right == nil {
//		node = node.left
//		return node
//	}
//	leftmostrightside := node.right
//	for {
//		//find smallest value on the right side
//		if leftmostrightside != nil && leftmostrightside.left != nil {
//			leftmostrightside = leftmostrightside.left
//		} else {
//			break
//		}
//	}
//	node.key, node.value = leftmostrightside.key, leftmostrightside.value
//	node.right = remove(node.right, node.key)
//	return node
//}
//
//func search(node *Node, key int) bool {
//	if node.key == key {
//		return true
//	}
//	if node.left != nil && key < node.key {
//		if node.left.key == key {
//			return true
//		} else {
//			return search(node.left, key)
//		}
//	} else if node.right != nil && key >= node.key {
//		if node.right.key == key {
//			return true
//		} else {
//			return search(node.right, key)
//		}
//	}
//	return false
//}
//
//// 这种方法更简单
//func search2(node *Node, key int) bool {
//	if node == nil {
//		return false
//	}
//	if key < node.key {
//		return search2(node.left, key)
//	}
//	if key > node.key {
//		return search2(node.right, key)
//	}
//	return true
//
//}
//func inOrderTraverse(node *Node) {
//	//fmt.Println("aaaaaaaa")
//
//	if node.left != nil {
//		inOrderTraverse(node.left)
//	}
//	fmt.Printf("key:%v,value:%v\n", node.key, node.value)
//	if node.right != nil {
//		inOrderTraverse(node.right)
//	}
//}
//
//func preOrderTraverse(node *Node) {
//	//fmt.Println("aaaaaaaa")
//	fmt.Printf("key:%v,value:%v\n", node.key, node.value)
//
//	if node.left != nil {
//		preOrderTraverse(node.left)
//	}
//	if node.right != nil {
//		preOrderTraverse(node.right)
//	}
//}
//
//func postOrderTraverse(node *Node) {
//	//fmt.Println("aaaaaaaa")
//
//	if node.left != nil {
//		postOrderTraverse(node.left)
//	}
//	if node.right != nil {
//		postOrderTraverse(node.right)
//	}
//	fmt.Printf("key:%v,value:%v\n", node.key, node.value)
//
//}
//func TestSearch(bst *BinarySearchTree, key int) {
//	ok := bst.Search(key)
//	if !ok {
//		fmt.Printf("not found key:%d\n", key)
//	} else {
//		fmt.Printf("found key:%d\n", key)
//	}
//}
//
//func (bst *BinarySearchTree) String() {
//	bst.lock.Lock()
//	defer bst.lock.Unlock()
//	fmt.Println("------------------------------------------------")
//	stringify(bst.root, 0)
//	fmt.Println("------------------------------------------------")
//}
//
//// internal recursive function to print a tree
//func stringify(n *Node, level int) {
//	if n != nil {
//		format := ""
//		for i := 0; i < level; i++ {
//			format += "       "
//		}
//		format += "---[ "
//		level++
//		stringify(n.left, level)
//		fmt.Printf(format+"%d\n", n.key)
//		stringify(n.right, level)
//	}
//}

func doReq(ctx context.Context, t string) {
	for {

		select {
		case <-ctx.Done():
			fmt.Println("stop ", t)
			return
		default:
			fmt.Println("default", t)
		}
		time.Sleep(time.Second)
		//fmt.Println("ctx.value", t, ctx.Value("key1"))

	}

}
func main() {
	ctx1, cancel1 := context.WithCancel(context.Background())
	ctx, cancel := context.WithCancel(ctx1)
	select {
	case <-ctx.Done():
		fmt.Println()
	default:
		fmt.Println("bbbbbbbbbbbbbbbbb")
	}
	fmt.Printf("aaaaaaaaaa")
	go doReq(ctx, "worker1")
	go doReq(ctx, "worker2")
	time.Sleep(3 * time.Second)
	cancel()
	cancel1()
	time.Sleep(8 * time.Second)
	var ss map[int]int
	ss[1] = 1
	runtime.Breakpoint()
}
